// var i;
// exports.Decorate = void 0;
// (i = exports.Decorate || (exports.Decorate = {})).promisify = function (t, n, o) {
//     var i = o.value;
//     o.value = function () {
//         var t = this;
//         var n = [];
//         for (var o = 0; o < arguments.length; o++) {
//             n[o] = arguments[o];
//         }
//         return n.length > 1 && "function" == typeof n[n.length - 1]
//             ? new Promise(function (e, o) {
//                   var a = n.pop();
//                   i.apply(
//                       t,
//                       __spreadArrays(n, [
//                           function (t, n) {
//                               if (a) {
//                                   a(t, n);
//                               }
//                               t ? o(t) : e(n);
//                           }
//                       ])
//                   );
//               })
//             : 1 == n.length && "object" == typeof n[0]
//             ? new Promise(function (e, o) {
//                   var r = n[0].success;
//                   n[0].success = function (t) {
//                       if (r) {
//                           r(t);
//                       }
//                       e(t);
//                   };
//                   var a = n[0].fail;
//                   n[0].fail = function (e) {
//                       if (a) {
//                           a(e);
//                       }
//                       o(e);
//                   };
//                   i.apply(t, n);
//               })
//             : i.apply(this, n);
//     };
// };
// i.instance = function (e) {
//     Object.defineProperties(e, {
//         _instance: {
//             value: null,
//             writable: !0
//         },
//         Instance: {
//             get: function () {
//                 return e._instance || (e._instance = new e());
//             },
//             set: function (t) {
//                 e._instance = t;
//             }
//         }
//     });
// };


// /**
//  * @namespace Decorate
//  * @description This namespace provides utility methods for decorating functions.
//  */
// var internalDecorate;
// exports.Decorate = void 0;

// /**
//  * @description Adds a promisify function to the Decorate namespace.
//  * @param {Function} target - The target function.
//  * @param {string} propertyName - The name of the property.
//  * @param {Object} descriptor - The property descriptor.
//  */
// (internalDecorate = exports.Decorate || (exports.Decorate = {})).promisify = function (target, propertyName, descriptor) {
//     var originalMethod = descriptor.value;
//     descriptor.value = function () {
//         var context = this;
//         var args = [];
        
//         // Capture arguments passed to the function
//         for (var argIndex = 0; argIndex < arguments.length; argIndex++) {
//             args[argIndex] = arguments[argIndex];
//         }
        
//         // If the last argument is a callback function, wrap it in a promise
//         return args.length > 1 && typeof args[args.length - 1] === "function"
//             ? new Promise(function (resolve, reject) {
//                   var callback = args.pop();
//                   originalMethod.apply(
//                       context,
//                       __spreadArrays(args, [
//                           function (error, result) {
//                               if (callback) {
//                                   callback(error, result);
//                               }
//                               error ? reject(error) : resolve(result);
//                           }
//                       ])
//                   );
//               })
//             // If the single argument is an object, handle success and fail properties
//             : args.length === 1 && typeof args[0] === "object"
//             ? new Promise(function (resolve, reject) {
//                   var successHandler = args[0].success;
//                   args[0].success = function (result) {
//                       if (successHandler) {
//                           successHandler(result);
//                       }
//                       resolve(result);
//                   };
//                   var failHandler = args[0].fail;
//                   args[0].fail = function (error) {
//                       if (failHandler) {
//                           failHandler(error);
//                       }
//                       reject(error);
//                   };
//                   originalMethod.apply(context, args);
//               })
//             // Default function call
//             : originalMethod.apply(this, args);
//     };
// };

// // Instance decorator for singleton pattern
// /**
//  * @description Singleton pattern decorator for creating or accessing an instance.
//  * @param {Function} ClassConstructor - The class constructor.
//  */
// internalDecorate.instance = function (ClassConstructor) {
//     Object.defineProperties(ClassConstructor, {
//         _instance: {
//             value: null,
//             writable: true
//         },
//         Instance: {
//             get: function () {
//                 return ClassConstructor._instance || (ClassConstructor._instance = new ClassConstructor());
//             },
//             set: function (instance) {
//                 ClassConstructor._instance = instance;
//             }
//         }
//     });
// };



// 定义一个命名空间 Decorate 并导出
exports.Decorate = exports.Decorate || {};

/**
 * 将目标方法 promisify（转化为基于 Promise 的方法）
 * @param {Object} target - 装饰的目标对象
 * @param {string} propertyKey - 被装饰的方法名
 * @param {Object} descriptor - 方法的描述符
 */
exports.Decorate.promisify = function (target, propertyKey, descriptor) {
    // 保存原始方法
    const originalMethod = descriptor.value;

    // 替换为新的方法
    descriptor.value = function (...args) {
        // 当前方法的上下文
        const context = this;

        // 如果最后一个参数是回调函数
        if (args.length > 1 && typeof args[args.length - 1] === "function") {
            return new Promise((resolve, reject) => {
                const callback = args.pop();

                // 调用原始方法，并附加包装后的回调函数
                originalMethod.apply(
                    context,
                    [...args, function (err, result) {
                        if (callback) {
                            callback(err, result);
                        }
                        err ? reject(err) : resolve(result);
                    }]
                );
            });
        }
        // 如果只有一个参数，且为对象类型
        else if (args.length === 1 && typeof args[0] === "object") {
            return new Promise((resolve, reject) => {
                const options = args[0];

                // 保存原始 success 回调
                const originalSuccess = options.success;
                options.success = function (result) {
                    if (originalSuccess) {
                        originalSuccess(result);
                    }
                    resolve(result);
                };

                // 保存原始 fail 回调
                const originalFail = options.fail;
                options.fail = function (error) {
                    if (originalFail) {
                        originalFail(error);
                    }
                    reject(error);
                };

                // 调用原始方法
                originalMethod.apply(context, args);
            });
        }
        // 其他情况，直接调用原始方法
        else {
            return originalMethod.apply(context, args);
        }
    };
};

/**
 * 为目标类添加单例模式支持
 * @param {Function} constructor - 类构造函数
 */
exports.Decorate.instance = function (constructor) {
    Object.defineProperties(constructor, {
        // 私有的 _instance 属性，用于存储单例
        _instance: {
            value: null,
            writable: true
        },
        // 公共的 Instance 属性，用于获取或设置单例
        Instance: {
            get: function () {
                // 如果单例不存在，则创建一个新的实例
                if (!constructor._instance) {
                    constructor._instance = new constructor();
                }
                return constructor._instance;
            },
            set: function (instance) {
                // 设置单例
                constructor._instance = instance;
            }
        }
    });
};
